'''
Clase que prueba el funcionamiento de los metodos del proyecto
Modificacion: It5
'''
import unittest
from aps.models.usuario import *
from aps.models.base import DBSession
from aps import app
from aps.models.rol import *
from flask import jsonify
from aps.models import bdsession
from aps.models.rolpermiso import *
from aps.models.proyectorol import *
from aps.models.proyecto import *
from aps.models.atributo import *
from aps.models.fase import *
from aps.models.item import *
from aps.models.tipoitem import *
from aps.models.lineabase import *
from aps.models.solicituditem import *
from aps.models.solicitud import *

from flask import request

def initTestingBD():
    from aps.models import inicializar
    bdsession = DBSession()
    return bdsession

class TestSolicitudDECambio(unittest.TestCase):
    def setUp(self):
        self.sesion = initTestingBD()
        self.app = app.test_client()
       
    def tearDown(self):
        self.sesion =  exit
        
    def testCrearSolicitud(self):
        print '\nCASO DE USO: CREAR SOLICITUD'
        print 'creando solicitud'
        descripcion   = 'descripcion'
        data          = 1,2,3
        usuario = bdsession.query(Usuario).filter_by(nick='admin').first()
        idusuario = usuario.id
        print "U",idusuario
        crearFase       = Fase('Fase01', 'descripcion', '1/1/1', '1/1/1', 'observaciones', 'A')
        bdsession.add(crearFase)  
        fase = bdsession.query(Fase).filter_by(estado='A').first()
        id_fase = fase.id
        print "F", id_fase
        # se agrega a la BD
        sol      = Solicitud(idusuario, id_fase, descripcion, 'ACTIVO')
        bdsession.add(sol)
        soli =bdsession.query(Solicitud).filter_by(idusuario=idusuario).first()
        print "model id> ", soli.id
        self.assertEqual(soli.idusuario, idusuario, "OK")
        #bdsession.flush()
        solicitud     = bdsession.query(Solicitud).filter_by(id=soli.id).first()
         
        print "solicitud", solicitud
#         for id_item in data:
#             model2    = SolicitudItem(solicitud.id, id_item)
#             bdsession.add(model2)
        print 'Proceso exitoso' 
        print '----------------------------------------\n'  

#     def testModificarSolicitud(self):
        print '\nCASO DE USO: MODIFICAR SOLICITUD'
        print 'modificando solicitud'
        usuario = bdsession.query(Usuario).filter_by(nick='admin').first()
        idusuario = usuario.id
        soli = bdsession.query(Solicitud).filter_by(idusuario=idusuario).first()
        id            = soli.id
        print "id",id
        idusuario     = soli.idusuario
        descripcion   = 'descri'
        #received      = 1
        idfase       = soli.idfase
        data          = 1,2,3
        # se modifica 
        model         = Solicitud(idusuario, idfase, descripcion, 'ACTIVO')
        model.id      = id
        bdsession.merge(model)  
        self.assertEqual(soli.descripcion, 'descri', "OK") 
        #bdsession.query(SolicitudItem).filter_by(idsolicitud=id).delete()
#         for id_item in data:
#             model2    = SolicitudItem(id, id_item)
#             bdsession.add(model2)
        print 'Proceso exitoso' 
        print '----------------------------------------\n'  
         
#     def testEliminarSolicitud(self):
        print "\nCASO DE USO: ELIMINAR SOLICITUD"
        print 'eliminando solicitud'
        us = bdsession.query(Usuario).filter_by(nick='admin').first()
        idusuario = us.id
        solicitud = bdsession.query(Solicitud).filter_by(idusuario=idusuario).first()
        if solicitud.idusuario is None:
            "No se puede borrar"
        else:
        # eliminamos de la BD
            bdsession.delete(solicitud)  
            sol = bdsession.query(Solicitud).filter_by(idusuario=idusuario).first()
            self.assertEqual(sol, None, "OK")
#        
        print 'Proceso exitoso' 
        print '----------------------------------------\n' 
            

class TestComite(unittest.TestCase):
    def setUp(self):
        self.sesion = initTestingBD()
        self.app = app.test_client()
       
    def tearDown(self):
        self.sesion =  exit
        
#     def testCrearComite(self):
#         print '\nCREAR COMITE'
#         print 'creando comite...'
#         #received   = eval(request.form['data'])
#         # ids de usuarios asignados
#         data   = 1,2,3
#         #received['data']
#         # id del proyecto al que se le asigna un usuario
#         id_proyecto = 1
#          # elimiminamos todos los miembros del comite para volver a reemplazar
#         usuarios = bdsession.query(ProyectoUsuario).filter_by(idproyecto=id_proyecto).all()
#         for usuario_comite in usuarios:
#             usuario_comite.comite=0
#         # marcamos los usuarios como miembros del comite
#         for idusuario in data:
#             usuario_comite=bdsession.query(ProyectoUsuario).filter_by(idproyecto=id_proyecto,idusuario=idusuario).first()
#             self.assertEqual(usuario_comite.idproyecto, id_proyecto, "OK")
#             self.assertEqual(usuario_comite.idusuario, idusuario, "OK")
#             usuario_comite.comite=1
#         print 'Proceso exitoso' 
#         print '----------------------------------------\n'
# 
#     def testModificarComite(self):
#         print '\nMODIFICAR COMITE'
#         print 'modificando comite...'
#         #received   = eval(request.form['data'])
#         # ids de usuarios asignados
#         data   = 1,2,3
#         #received['data']
#         # id del proyecto al que se le asigna un usuario
#         id_proyecto = 1
#          # elimiminamos todos los miembros del comite para volver a reemplazar
#         usuarios = bdsession.query(ProyectoUsuario).filter_by(idproyecto=id_proyecto).all()
#         for usuario_comite in usuarios:
#             usuario_comite.comite=0
#         # marcamos los usuarios como miembros del comite
#         for idusuario in data:
#             usuario_comite=bdsession.query(ProyectoUsuario).filter_by(idproyecto=id_proyecto,idusuario=idusuario).first()
#             self.assertEqual(usuario_comite.idproyecto, id_proyecto, "OK")
#             self.assertEqual(usuario_comite.idusuario, idusuario, "OK")
#             usuario_comite.comite=1
#         print 'Proceso exitoso' 
#         print '----------------------------------------\n'
        
    def testConsultaMiembrosComite(self):
        print '\nCONSULTA DE MIEMBROS DE COMITE'
        print 'consultando miembros del comite...'
        id_proyecto = 1
        proyecto    = bdsession.query(Proyecto).filter_by(id=id_proyecto).first()
        sentencia='select * from Usuario where id  in (select idusuario from ProyectoUsuario where idproyecto=\'{0}\' and comite=1)'
        usuarios_asignados = bdsession.query(Usuario).from_statement(sentencia.format(id_proyecto)).all()
        data = []
        for usuario in usuarios_asignados:
            item = {}
            item['id']      = usuario.id
            item['ci']      = usuario.ci
            item['nick']    = usuario.nick
            item['nombres']    = usuario.nombres
            item['apellidos']    = usuario.apellidos
            item['direccion']    = usuario.direccion
            item['email']    = usuario.email
            data.append(item)
            self.assertNotEqual(data, None, "ok")
        print 'Proceso exitoso' 
        print '----------------------------------------\n'
        
#################################


class TestLB(unittest.TestCase):
    def setUp(self):
        self.sesion = initTestingBD()
        self.app = app.test_client()
        
    def tearDown(self):
        self.sesion =  exit
         
    def testcrearLB(self):
        print '\nCREAR LINEA BASE'
        print 'creando linea base...'
        crearFase       = Fase('Fase01', 'descripcion', '1/1/1', '1/1/1', 'observaciones', 'NO-INICIADO')
        bdsession.add(crearFase)    
        print 'comprobando que la linea base ha sido creada'
        fase          = bdsession.query(Fase).filter_by(nombre = 'Fase01').first()
        idFase = fase.id
        nombre        = 'nombreLB'
        descripcion   = 'descripcion'
        received      = 'data'
        data          = 'data'
        # se agrega a la BD
        model         = Lineabase(nombre, descripcion, idFase)
        bdsession.add(model)
        lineabase     = bdsession.query(Lineabase).filter_by(idfase=idFase).first()
        self.assertEqual(lineabase.idfase,idFase,"Exito")
        print 'Proceso exitoso' 
        print '----------------------------------------\n'
 
    #def testModificarLB(self):
        print '\nMODIFICAR LINEA BASE'
        print 'Modificar linea base...'
        nombre       = 'lalala'
        descripcion  = 'descripcionLB'
        lineabase     = bdsession.query(Lineabase).filter_by(idfase=idFase).first()
        model        = Lineabase(nombre,descripcion, idFase)
        idLB = lineabase.id
        model.id     = idLB
        bdsession.merge(model)
        lineabase     = bdsession.query(Lineabase).filter_by(id=idLB).first()
        self.assertEqual(lineabase.nombre,nombre,"Exito")
        print 'Proceso exitoso' 
        print '----------------------------------------\n'   
   
    #def testEliminarLB(self):
        print '\nELIMINAR LINEA BASE'
        print 'Eliminar linea base...'
        lineabase     = bdsession.query(Lineabase).filter_by(id=idLB).first()
        bdsession.delete(lineabase)
        lineabase     = bdsession.query(Lineabase).filter_by(id=idLB).first()
        self.assertEqual(lineabase, None, "Eliminado con exito")
        bdsession.delete(fase)
        print 'Proceso exitoso' 
        print '----------------------------------------\n'   
         
#     def testBuscar_lineabase(self):
#         print '\nBUSCAR LINEA BASE'
#         print 'Buscando linea base...'
#         fase          = bdsession.query(Fase).filter_by(nombre = 'Fase01').first()
#         if fase is not None:
#             lineabases = None
#             filtro     = 'nombre'
#             valor      = 'nombreLB'
#             print "    ...con filtro (", filtro, ") y valor (", valor, ")"
#             sentencia  = 'SELECT * from Lineabasea WHERE idfase={0} AND {1} =\'{2}\''.format(id_fase,filtro,valor)
#             lineabases = bdsession.query(Tipoitem).from_statement(sentencia).all()
#             data = []
#             for lineabase in lineabases:
#                 item = {}
#                 item['id'] = lineabase.id
#                 #item['fase'] = lineabase.idfase
#                 item['nombre'] = lineabase.nombre
#                 item['descripcion'] = lineabase.descripcion
#                 data.append(item)
#                 self.assertNotEqual(data, None, "ok")
#         print 'Proceso exitoso' 
#         print '----------------------------------------\n'
     
    def testListar_lineabase(self):
        print '\nLISTAR LINEA BASE'
        print 'Listando linea base...'
        fase          = bdsession.query(Fase).filter_by(nombre = 'Fase01').first()
        if fase is not None:
            id_fase = fase.id
            lineabases = bdsession.query(Lineabase).filter_by(idfase=id_fase).all()
            self.assertNotEqual(lineabases, None, "OK")
        print 'Proceso exitoso' 
        print '----------------------------------------\n'
     
    def testAdjuntarArchivo(self):
        print '\nADJUNTAR ARCHIVO'
        print 'Adjuntando archivo...'
#         fase          = bdsession.query(Fase).filter_by(nombre = 'Fase01').first()
#         id_fase = fase.id
#         lineabases = bdsession.query(Lineabase).filter_by(idfase=id_fase).all()
#         self.assertNotEqual(lineabases, None, "OK")
        print 'Proceso exitoso' 
        print '----------------------------------------\n'
        
            


class TestItem(unittest.TestCase):
    def setUp(self):
        self.sesion = initTestingBD()
        self.app = app.test_client()
        
    def tearDown(self):
        self.sesion =  exit
          
    def testCrearTipoItem(self):
        print '\nCREAR TIPO ITEM'
        print 'creando tipo item...'
        nombre        = 'nombre'
        descripcion   = 'descripcion'
        prefijo       = 'prefijo'
          
        # se agrega a la BD
        model         = Tipoitem(nombre, descripcion, prefijo)
        bdsession.add(model)
        print 'Proceso exitoso' 
        print '----------------------------------------\n'
           
#     def testCrearItem(self):
#         id_fase     = 39
#         id_tipoitem = 1
# #         # Tipo de item
# #         tipoitem   = bdsession.query(Tipoitem).filter_by(id=id_tipoitem).first()
# #         if tipoitem is None:
# #             print "tipoitem None"
# #         # Calculamos la numeracion dentro de la fase para el tipo de item
# #         maxnumfase = bdsession.query(func.max(Item.numfase)).filter_by(idtipoitem=id_tipoitem, idfase=id_fase).scalar()
# #         numfase    = ''
# #         if maxnumfase is None:
# #             print "Maxnumfase is None"
# #             numfase = tipoitem.prefijo + '-1'
# #         else:
# #             numfase = tipoitem.prefijo + '-' + str(int(str(maxnumfase[4:])) + 1)
# #         #Obtenemos los demas atributos base necesarios
#         nombre       = 'nom'
#         descripcion  = 'desc'
#         prioridad    = 1
#         complejidad  = 4
#         version      = 1
#         estado       = 'ACTIVO'
#         id_lineabase = None
#         numfase = 1
#         # Creamos el nuevo item y guardamos en la BD
#         model = Item(numfase, nombre, descripcion, version, prioridad, complejidad, estado, id_lineabase, id_tipoitem, id_fase)
#         bdsession.add(model)
      
 
 
class TestFase(unittest.TestCase):
    def setUp(self):
        self.sesion = initTestingBD()
        self.app = app.test_client()
       
    def tearDown(self):
        self.sesion =  exit
           
    def testCrearFase(self):
        print '\nCREAR FASE'
        print 'creando fase...' 
        nombre          = 'Fase01'
        descripcion     = 'descripcion'
        fechainicio     = '1/1/1'
        fechafin        = '1/1/1'
        observaciones   = 'observaciones'
        estado          = 'NO-INICIADO'
        # Id del proyecto a asignar fases
        id_proyecto     = 1
        crearFase       = Fase(nombre, descripcion, fechainicio, fechafin, observaciones, estado)
        bdsession.add(crearFase)    
        print 'comprobando que la fase ha sido creada'
        fase          = bdsession.query(Fase).filter_by(nombre = 'Fase01').first()
        self.assertEqual(fase.nombre,'Fase01',"Exito")
        print 'Proceso exitoso' 
        print "FASE ",fase.id
        print '----------------------------------------\n'
          
    #def testModificarFase(self):
        print '\nMODIFICAR FASE'
        print 'modificando fase...' 
        nombre        = 'nombredefase0'
        descripcion   = 'descripcion'
        fechainicio   = '1/1/1'
        fechafin      = '1/1/1'
        observaciones = 'observaciones'
        fase          = bdsession.query(Fase).filter_by(descripcion='descripcion').first()
        #print fase.id
        estado        = 'A'
        # se modifica en la BD
        model         = Fase(nombre, descripcion, fechainicio, fechafin, observaciones, estado)
        model.id      = fase.id
        bdsession.merge(model) 
        print 'comprobando que la fase ha sido modificada'
        self.assertEqual(fase.descripcion,'descripcion', "Ok")
        print 'Proceso exitoso' 
        print '----------------------------------------\n'
          
#     def testEliminarFase(self):
#         print '\nELIMINAR FASE'
#         print 'eliminando fase...'    
#         id_proyecto   = 1
#         id            = 1
#         fase          = bdsession.query(Fase).filter_by(descripcion='descripcion').first()
#         # Actualizamos el numero de fases dentro del proyecto
#         proyecto        = bdsession.query(Proyecto).filter_by(id=id_proyecto).first()
#         proyecto.nfases = proyecto.nfases-1
#         bdsession.merge(proyecto)
#         #bdsession.commit()
#         # Actualizamos el orden de las demas fases
#         sentencia       = 'SELECT * from ProyectoFase WHERE idproyecto = {0} and orden > (SELECT orden from ProyectoFase WHERE idproyecto ={1} and idfase ={2})'.format(id_proyecto,id_proyecto,id)
#         proyectofases   = bdsession.query(ProyectoFase).from_statement(sentencia).all()
#         for f in proyectofases:
#             f.orden = f.orden-1
#             bdsession.merge(f)
#             #bdsession.commit()
#         # Eliminamos la fase
#         fase.eliminar_dependencias()
#         bdsession.refresh(fase)
#         bdsession.delete(fase)
#         #bdsession.commit()
#         print 'comprobando que la fase ha sido eliminada'
#         fase          = bdsession.query(Fase).filter_by(nombre='nombredefase0').first()
#         if fase is None:
#             print "None"
#         #print fase.nombre
#         self.assertEqual(fase, None, "Ok")
#         print 'Proceso exitoso' 
#         print '----------------------------------------\n'
# #Errores ?
class TestAtributo(unittest.TestCase):
    def setUp(self):
        self.sesion = initTestingBD()
        self.app = app.test_client()
       
    def tearDown(self):
        self.sesion =  exit
           
    def testCrearAtributo(self): 
        print '\nCREAR ATRIBUTO'
        print 'creando atributo...' 
        nombre   = 'nombre_del_atributo1'
        tipodato = 'tipodato'
        valordef = 1
        # se agrega a la BD
        model    = Atributo(nombre, tipodato, valordef)
        bdsession.add(model)
        print 'comprobando que el atributo ha sido creado'
        atributo = bdsession.query(Atributo).filter_by(nombre='nombre_del_atributo1').first()
        print atributo.nombre
        self.assertEqual(atributo.nombre,'nombre_del_atributo1')
        print 'Proceso exitoso' 
        print atributo.id
        print '----------------------------------------\n'
   
           
    #def test_modificar(self):
        print '\nMODIFICAR ATRIBUTO'
        print 'modificando atributo...'
        id       = atributo.id
        nombre   = 'nombre_prueba'
        tipodato = 'tipodato'
        valordef = 'valordef'
        # Se modifica en la BD
        modificarAtributos    = Atributo(nombre,tipodato,valordef)
        modificarAtributos.id = id
        bdsession.merge(modificarAtributos)
        print 'comprobando cambio en el nombre del atributo'
        atributo = bdsession.query(Atributo).filter_by(id=id).first()
        self.assertEqual(atributo.nombre, 'nombre_prueba')
        #assert res.status_int == 200
        print 'Proceso exitoso' 
        print '----------------------------------------\n'
          
    #def test_eliminar(self):
        print '\nCASO DE USO: ELIMINAR ATRIBUTO'
        print 'eliminando atributo con id : 1'
        id       = atributo.id
        atributo = bdsession.query(Atributo).filter_by(id=id).first()
        print 'comprobando que el atributo no exista'
        if (atributo == None):
            self.assertEqual(atributo, None,"No existe el atributo con id 10")
        else:
            self.assertEqual(atributo.id, id,"Atributo eliminado")
            bdsession.delete(atributo)
        print 'Proceso exitoso' 
        print '----------------------------------------\n'
   
class TestProyecto(unittest.TestCase):
      
    def setUp(self):
        self.sesion = initTestingBD()
        self.app = app.test_client()
      
    def tearDown(self):
        self.sesion =  exit
      
    def testCrearProyecto(self):
        print '\nCREAR PROYECTO'
        print 'creando proyecto ...'
        nombre = 'proy_ti1'
        model         = Proyecto(nombre, 'proyecto_test', '1/1/1', '2/2/2', 'proyecto_test', 0, 0, 'proyecto_test')
        bdsession.add(model)
        print 'comprobando que el proyecto exista'
         
        proyecto =  bdsession.query(Proyecto).filter_by(nombre=nombre).first()
        print proyecto
        self.assertEqual(proyecto.nombre,nombre , "OK")
        #self.assertTrue(proyecto,msg='El proyecto no existe')
        print 'Proceso Exitoso'
        print '----------------------------------------\n'
          
    #def testModificarProyecto(self):
        print '\nMODIFICAR PROYECTO'
        print 'modificando proyecto ...'
        print 'comprobando modificacion de proyecto'
        nombre = 'proy_ti1'
        proyecto = bdsession.query(Proyecto).filter_by(nombre=nombre).first()
        # se modifica en la BD
        nuevonombre = 'proyetest_i'
        model         = Proyecto(nuevonombre,'proyecto_test','1/1/1/','2/2/2','proyecto_test',1,2,'proyecto_test')
        model.id      = proyecto.id
        bdsession.merge(model)
        self.assertEqual(proyecto.nombre, nuevonombre)
        print 'Proceso Exitoso'
        print '----------------------------------------\n'
  
    #def testEliminarProyecto(self):
        print '\nELIMINAR PROYECTO'
        print 'eliminando proyecto con id = 50'
        print 'comprobando que el proyecto no exista'
        #nuevonombre = 'proyetesti2'
        proyecto = bdsession.query(Proyecto).filter_by(nombre=nuevonombre).first()
        id = proyecto.id
        bdsession.delete(proyecto)
        proyecto = bdsession.query(Proyecto).filter_by(id=id).first()
        self.assertEqual(proyecto, None)
        print 'Proceso Exitoso'
        print '----------------------------------------\n'
###################################
#2da y 1ra Iteracion  
           
class TestRol (unittest.TestCase):
    def setUp(self):
        self.sesion = initTestingBD()
        self.app = app.test_client()
       
    def tearDown(self):
        self.sesion =  exit
      
    def testAgregarRol(self):
        print '\nCREAR ROL'
        print 'creando rol ...'
        nuevoRol = Rol('Rol2', 'Descripcion_de_Rol1')
        bdsession.add(nuevoRol)
        print 'Proceso exitoso'
        print '----------------------------------------\n'
           
    def testModificarRol(self):
        print '\nMODIFICAR ROL'
        print 'Modificando Rol...'
        id_rol = 2
        rol     = bdsession.query(Rol).filter_by(id=id_rol).first()
        if len(rol.fases) == 0 or len(rol.usuarios_x_proyecto) == 0:
            modificarRol = Rol('Lider de proyecto', 'Descripcion_de_Roles')
            modificarRol.id      = id_rol
            bdsession.merge(modificarRol) 
        print 'Proceso exitoso'    
        print '----------------------------------------\n'
   
    def testEliminarRol(self):
        print '\nELIMINAR ROL'
        print 'Eliminando Rol...'
        id_rol  = 2
        rol     = bdsession.query(Rol).filter_by(nombre = 'Rol2').first()
        # Verificamos que no este asociado a un usuario o a una fase
        if len(rol.fases) != 0 or len(rol.usuarios_x_proyecto) != 0:
            print 'No se puede eliminar el Rol. Esta asociado a otra tabla'
        else:
            # Eliminamos las relaciones con los permisos y proyecto
            bdsession.query(RolPermiso).filter_by(idrol=id_rol).delete(synchronize_session=False)
            bdsession.query(ProyectoRol).filter_by(idrol=id_rol).delete(synchronize_session=False)
            # Eliminamos el rol
            bdsession.delete(rol)
            print 'Proceso Exitoso'
            print '----------------------------------------\n'
   
   
class TestUsuario(unittest.TestCase):
    
    def setUp(self):
        self.sesion = initTestingBD()
        self.app = app.test_client()
        
    def tearDown(self):
        self.sesion =  exit
              
    def testAgregarUsuario(self):
        print '\nCREAR USUARIO'
        print 'Agregando Usuario...'
        try:
            nuevoUsuario = Usuario(123456,'admini','admini','admini','123','admin@gmail.com',123456,'calle admin 123','OBS','Femenino','21/02/91')
        except :
            return jsonify({ 'success': False})
            pass
        self.sesion.add(nuevoUsuario)     
        print 'Proceso exitoso'
        print '----------------------------------------\n'
        return self.sesion
          
    #def testModificarUsuario(self):
        print '\nMODIFICAR USUARIO'
        print 'Modificando Usuario...'
        nombre = 'admini'
        modificarUsuario = bdsession.query(Usuario).filter_by(nombre=nombre).first()
        id = modificarUsuario.id
            
        if len(modificarUsuario.roles_x_proyecto) == 0:
            modificarUsuario = Usuario(123456,'administrador','administrador','administrador','123','adminis@gmail.com',123456,'calle admin 12345','OBS','Femenino','21/02/91')
            
            bdsession.merge(modificarUsuario)
        print 'Proceso exitoso'
        print '----------------------------------------\n'
              
    #def testEliminarUsuario(self):
        print '\nELIMINAR USUARIO'
        print 'Eliminando Usuario...'
        eliminarUsuario = bdsession.query(Usuario).filter_by(id=id).first()
            
        if len(eliminarUsuario.roles_x_proyecto) == 0:
            bdsession.delete(eliminarUsuario)
        else:
            print 'No se puede eliminar el Usuario. Esta asociado a otra tabla'
        print 'Proceso exitoso'
        print '----------------------------------------\n'

  
class TestLogin(unittest.TestCase):
   
    def setUp(self):
        self.sesion = initTestingBD()
        self.app = app.test_client()
       
    def tearDown(self):
        self.sesion =  exit
           
    def testLogin(self):
        bdsession = DBSession()
        print '    Probando Login...'
        nickname = 'admin'
        try:  
            usuario_login =bdsession.query(Usuario).filter_by(nick = nickname).one() 
        except :
            print 'Error al encontrar el nick'
            pass
        if usuario_login.nick != nickname:
            print 'Usuario incorrecto'
            self.assertEqual(usuario_login, nickname, "Usuario Incorrecto")
        elif usuario_login.password != '123' :
            self.assertEqual(usuario_login.password,'123', "Contrasenha incorrecta")
            print 'Error: Contrasenha incorrecta'
        else:
            self.assertNotEqual(usuario_login,nickname,"a")
            print 'Proceso exitoso' 
            print '----------------------------------------\n'     
     
                


if __name__ == "__main__":
    unittest.main()
